package cn.hloger.spider.demo.dataxDemo.utils;

import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

/**
 * @Author: LENOVO
 * @Description:
 * @Date: 2022/7/27 15:30
 * @Version: 1.0
 */
@Component
@Slf4j
public class ElasticsearchExtendUtil {
//
//    @Resource
//    private EsRestApiService esRestApiService;
//
//    public static EsRestApiService service;
//
//    @Resource
//    public ElasticsearchProperties properties;
//
//    public static ElasticsearchProperties configs;
//
//    /**
//     * @PostContruct是spring框架的注解 spring容器初始化的时候执行该方法
//     */
//    @PostConstruct
//    public void init() {
//        service = this.esRestApiService;
//        configs = this.properties;
//    }
//
//    /**
//     * 创建索引
//     *
//     * @param index
//     * @return
//     */
//    public static boolean createIndex(String index) throws IOException {
//        boolean res = false;
//        try {
//            res = service.createIndex(index);
//        } catch (IOException e) {
//            log.error(e.getMessage(), e);
//            initEsClient();
//            res = service.createIndex(index);
//        }
//        return res;
//    }
//
//    /**
//     * 注销老客户端，重新初始化客户端
//     */
//    private static void initEsClient() {
//        try {
//            ElasticsearchConfig config = configs.getClient()[0];
//            String clientName = config.getClientName();
//            String clusterNodes = config.getClusterNodes();
//            RestHighLevelClient esClient = EsRestClientCache.getEsClient(clientName);
//            esClient.close();
//            if (!com.cestc.basictool.utils.StringUtils.isEmpty(clientName) && !com.cestc.basictool.utils.StringUtils.isEmpty(clusterNodes)) {
//                EsRestClientCache.initEsClient(clientName, clusterNodes, config.getUserName(), config.getPassword());
//            } else {
//                log.info("elasticsearch datasource:{" + clientName + "} 节点地址{" + clusterNodes + "}不能为空，跳过注入");
//            }
//        } catch (IOException e) {
//            log.error("重新初始化es客户端出错", e);
//        }
//    }
//
//    /**
//     * 创建索引
//     *
//     * @param index
//     * @return
//     */
//    public static boolean createIndex(String index, Settings settings) throws IOException {
//        boolean res = false;
//        try {
//            res = service.createIndex(index, settings);
//        } catch (IOException e) {
//            log.error(e.getMessage(), e);
//            initEsClient();
//            res = service.createIndex(index, settings);
//        }
//        return res;
//    }
//
//    /**
//     * 创建索引
//     *
//     * @param createIndexRequest
//     * @return
//     */
//    public static boolean createIndexRequest(CreateIndexRequest createIndexRequest) throws IOException {
//        boolean res = false;
//        try {
//            res = service.createIndex(createIndexRequest);
//        } catch (IOException e) {
//            log.error(e.getMessage(), e);
//            initEsClient();
//            res = service.createIndex(createIndexRequest);
//        }
//        return res;
//    }
//
//    /**
//     * 创建索引并指定索引的策略
//     *
//     * @param index  索引名称
//     * @param policy 对应生命周期策略
//     * @return
//     */
//    public static boolean createTTLIndex(String index, String policy) throws IOException {
//        boolean res = false;
//        Settings settings = Settings.builder().put("index.lifecycle.name", policy).build();
//        try {
//            res = service.createIndex(index, settings);
//        } catch (IOException e) {
//            log.error(e.getMessage(), e);
//            initEsClient();
//            res = service.createIndex(index, settings);
//        }
//        return res;
//    }
//
//    /**
//     * 创建索引并指定索引的策略
//     *
//     * @param index 索引名称
//     * @return
//     */
//    public static boolean createTTLIndex(String index) throws IOException {
//        boolean res = false;
//        Settings settings = Settings.builder().put("index.lifecycle.name", EsConstants.DEFAULT_TTL_POLICY).build();
//        try {
//            res = service.createIndex(index, settings);
//        } catch (IOException e) {
//            log.error(e.getMessage(), e);
//            initEsClient();
//            res = service.createIndex(index, settings);
//        }
//        return res;
//    }
//
//    /**
//     * 删除索引
//     *
//     * @param index
//     * @return
//     */
//    public static boolean deleteIndex(String index) throws IOException {
//        boolean res = false;
//        try {
//            res = service.deleteIndex(index);
//        } catch (IOException e) {
//            log.error(e.getMessage(), e);
//            initEsClient();
//            res = service.deleteIndex(index);
//        }
//        if (!res) {
//            log.info("删除索引" + index + "失败！");
//        }
//        return res;
//    }
//
//    /**
//     * 判断索引是否存在
//     *
//     * @param index
//     * @return
//     */
//    public static boolean isIndexExist(String index) throws IOException {
//        boolean exist = false;
//        try {
//            exist = service.isIndexExist(index);
//        } catch (IOException e) {
//            log.error(e.getMessage(), e);
//            initEsClient();
//            exist = service.isIndexExist(index);
//        }
//        return exist;
//    }
//
//    /**
//     * 数据添加，返回ID
//     *
//     * @param jsonObject 要增加的数据
//     * @param index      索引，类似数据库
//     * @param type       类型，类似表，7.8.0版本该参数已经废弃
//     * @param id         数据ID
//     * @return
//     */
//    public static String createData(JSONObject jsonObject, String index, String type, String id) throws IOException {
//        try {
//            return service.createData(jsonObject, index, type, id);
//        } catch (IOException e) {
//            log.error(e.getMessage(), e);
//            initEsClient();
//            return service.createData(jsonObject, index, type, id);
//        }
//    }
//
//    public static String createData(String jsonString, String indexName, String type, String id) throws IOException {
//        try {
//            return service.createData(jsonString, indexName, type, id);
//        } catch (IOException e) {
//            log.error(e.getMessage(), e);
//            initEsClient();
//            return service.createData(jsonString, indexName, type, id);
//        }
//    }
//
//
//    /**
//     * 同步批量提交数据
//     *
//     * @param objectList
//     * @param indexName
//     * @param type
//     * @return
//     * @throws IOException
//     */
//    public static int batchCreateData(List<Object> objectList, String indexName, String type) throws IOException {
//        try {
//            //同步批量提交
//            return service.batchCreateData(objectList, indexName, type, WriteRequest.RefreshPolicy.WAIT_UNTIL);
//        } catch (Exception e) {
//            log.error(e.getMessage(), e);
//            initEsClient();
//            return service.batchCreateData(objectList, indexName, type, WriteRequest.RefreshPolicy.WAIT_UNTIL);
//        }
//    }
//
//    /**
//     * 批量提交数据
//     *
//     * @param objectList
//     * @param indexName
//     * @param type
//     * @return
//     * @throws IOException
//     */
//    public static int batchCreateDataAsync(List<Object> objectList, String indexName, String type) throws IOException {
//        try {
//            //异步批量提交性能更好，10万条异步只需要3秒，批量要30秒
//            service.batchCreateDataAsync(objectList, indexName, type, new BulkProcessor.Listener() {
//
//                @Override
//                public void beforeBulk(long l, BulkRequest bulkRequest) {
//
//                }
//
//                @Override
//                public void afterBulk(long l, BulkRequest bulkRequest, BulkResponse bulkResponse) {
//
//                }
//
//                @Override
//                public void afterBulk(long l, BulkRequest bulkRequest, Throwable throwable) {
//
//                }
//            });
//            return objectList.size();
//            //return service.batchCreateData(objectList, indexName, type, WriteRequest.RefreshPolicy.WAIT_UNTIL);
//        } catch (Exception e) {
//            log.error(e.getMessage(), e);
//            initEsClient();
//            return service.batchCreateData(objectList, indexName, type, WriteRequest.RefreshPolicy.WAIT_UNTIL);
//        }
//    }
//
//    /**
//     * 数据添加
//     *
//     * @param jsonObject 要增加的数据
//     * @param index      索引，类似数据库
//     * @param type       类型，类似表，7.8.0版本该参数已经废弃
//     * @return
//     */
//    public static String createData(JSONObject jsonObject, String index, String type) throws IOException {
//        return createData(jsonObject, index, type, new IdRule().nextId());
//    }
//
//    /**
//     * 数据添加
//     *
//     * @param jsonObject 要增加的数据
//     * @param index      索引，类似数据库
//     * @param type       类型，类似表，7.8.0版本该参数已经废弃
//     * @return
//     */
//    public static String createData(String jsonObject, String index, String type) throws IOException {
//        return createData(jsonObject, index, type, new IdRule().nextId());
//    }
//
//
//    /**
//     * 数据添加，返回ID
//     *
//     * @param jsonObject 要增加的数据
//     * @param index      索引，类似数据库
//     * @param type       类型，类似表，7.8.0版本该参数已经废弃
//     * @param id         数据ID
//     * @return 响应200则返回true, 其它为false.
//     */
//    public static boolean createDoc(JSONObject jsonObject, String index, String type, String id) throws IOException {
//        try {
//            return service.createDocByObject(jsonObject, index, type, id);
//        } catch (IOException e) {
//            log.error(e.getMessage(), e);
//            initEsClient();
//            return service.createDocByObject(jsonObject, index, type, id);
//        }
//    }
//
//    /**
//     * 数据添加
//     *
//     * @param jsonObject 要增加的数据
//     * @param index      索引，类似数据库
//     * @param type       类型，类似表，7.8.0版本该参数已经废弃
//     * @return 响应200则返回true, 其它为false.
//     */
//    public static boolean createDoc(JSONObject jsonObject, String index, String type) throws IOException {
//        return createDoc(jsonObject, index, type, new IdRule().nextId());
//    }
//
//
//    /**
//     * 通过ID删除数据
//     *
//     * @param index 索引，类似数据库
//     * @param type  类型，类似表，7.8.0版本该参数已经废弃
//     * @param id    数据ID
//     * @return 如果状态是200，则返回true,否则返回false
//     */
//    public static boolean deleteDocById(String index, String type, String id) throws IOException {
//        try {
//            return service.deleteDocById(index, type, id);
//        } catch (IOException e) {
//            log.error(e.getMessage(), e);
//            initEsClient();
//            return service.deleteDocById(index, type, id);
//        }
//    }
//
//    /**
//     * 通过ID删除数据
//     *
//     * @param index 索引，类似数据库
//     * @param type  类型，类似表，7.8.0版本该参数已经废弃
//     * @param id    数据ID
//     * @return 如果状态是200，则返回true,否则返回false
//     */
//    public static void deleteDataById(String index, String type, String id) throws IOException {
//        try {
//            service.deleteDocById(index, type, id);
//        } catch (IOException e) {
//            log.error(e.getMessage(), e);
//            initEsClient();
//            service.deleteDocById(index, type, id);
//        }
//    }
//
//    /**
//     * 通过ID 更新数据
//     *
//     * @param jsonObject 要增加的数据
//     * @param index      索引，类似数据库
//     * @param type       类型，类似表，7.8.0版本该参数已经废弃
//     * @param id         数据ID
//     * @return 执行完成后返回true
//     */
//    public static boolean updateDocById(JSONObject jsonObject, String index, String type, String id) throws IOException {
//        try {
//            return service.updateDocByObjectId(jsonObject, index, type, id);
//        } catch (IOException e) {
//            log.error(e.getMessage(), e);
//            initEsClient();
//            return service.updateDocByObjectId(jsonObject, index, type, id);
//        }
//    }
//
//    /**
//     * 通过ID 更新数据
//     *
//     * @param jsonObject 要增加的数据
//     * @param index      索引，类似数据库
//     * @param type       类型，类似表，7.8.0版本该参数已经废弃
//     * @param id         数据ID
//     * @return
//     */
//    public static void updateDataById(JSONObject jsonObject, String index, String type, String id) throws IOException {
//        try {
//            service.updateDocByObjectId(jsonObject, index, type, id);
//        } catch (IOException e) {
//            log.error(e.getMessage(), e);
//            initEsClient();
//            service.updateDocByObjectId(jsonObject, index, type, id);
//        }
//    }
//
//    /**
//     * 通过ID获取数据
//     *
//     * @param index  索引，类似数据库
//     * @param type   类型，类似表，7.8.0版本该参数已经废弃
//     * @param id     数据ID
//     * @param fields 需要显示的字段，逗号分隔（缺省为全部字段）
//     * @return
//     */
//    public static Map<String, Object> searchDataById(String index, String type, String id, String fields) throws IOException {
//        String[] fieldArr = null;
//        if (!StringUtils.isEmpty(fields)) {
//            fieldArr = fields.split(",");
//        }
//        try {
//            return service.searchDataById(index, type, id, fieldArr, null);
//        } catch (IOException e) {
//            log.error(e.getMessage(), e);
//            initEsClient();
//            return service.searchDataById(index, type, id, fieldArr, null);
//        }
//    }
//
//    /**
//     * 使用分词查询,并分页
//     *
//     * @param index          索引名称
//     * @param type           类型名称,可传入多个type逗号分隔，7.8.0版本该参数已经废弃
//     * @param startPage      当前页
//     * @param pageSize       每页显示条数
//     * @param query          查询条件
//     * @param fields         需要显示的字段，逗号分隔（缺省为全部字段）
//     * @param sortField      排序字段
//     * @param highlightField 高亮字段
//     * @return
//     */
//    public static EsPage searchDataPage(String index, String type, int startPage, int pageSize, QueryBuilder query,
//                                        String fields, String sortField, String highlightField) throws IOException {
//        String[] fieldArr = null;
//        if (!StringUtils.isEmpty(fields)) {
//            fieldArr = fields.split(",");
//        }
//        try {
//            return service.searchDataPage(index, type, startPage, pageSize, query, fieldArr, null, sortField, highlightField);
//        } catch (IOException e) {
//            log.error(e.getMessage(), e);
//            initEsClient();
//            return service.searchDataPage(index, type, startPage, pageSize, query, fieldArr, null, sortField, highlightField);
//        }
//    }
//
//    /**
//     * 使用分词查询,并分页
//     *
//     * @param index          索引名称
//     * @param type           类型名称,可传入多个type逗号分隔，7.8.0版本该参数已经废弃
//     * @param startPage      当前页
//     * @param pageSize       每页显示条数
//     * @param query          查询条件
//     * @param fields         需要显示的字段，逗号分隔（缺省为全部字段）
//     * @param sortField      排序字段
//     * @param sortOrder      排序方式
//     * @param highlightField 高亮字段
//     * @return
//     */
//    public static EsPage searchDataPage(String index, String type, int startPage, int pageSize,
//                                        QueryBuilder query, String fields, String sortField,
//                                        SortOrder sortOrder, String highlightField) throws IOException {
//        String[] fieldArr = null;
//        if (!StringUtils.isEmpty(fields)) {
//            fieldArr = fields.split(",");
//        }
//        try {
//            return service.searchDataPage(index, type, startPage, pageSize, query, fieldArr, null, sortField, sortOrder, highlightField);
//        } catch (IOException e) {
//            log.error(e.getMessage(), e);
//            initEsClient();
//            return service.searchDataPage(index, type, startPage, pageSize, query, fieldArr, null, sortField, sortOrder, highlightField);
//
//        }
//    }
//
//    /**
//     * 使用分词查询
//     *
//     * @param index          索引名称
//     * @param type           类型名称,可传入多个type逗号分隔，7.8.0版本该参数已经废弃
//     * @param query          查询条件
//     * @param size           文档大小限制
//     * @param fields         需要显示的字段，逗号分隔（缺省为全部字段）
//     * @param sortField      排序字段
//     * @param highlightField 高亮字段
//     * @return
//     */
//    public static List<Map<String, Object>> searchListData(String index, String type, QueryBuilder query, Integer size,
//                                                           String fields, String sortField, String highlightField) throws IOException {
//        try {
//            return service.searchListData(index, type, query, size, fields, sortField, highlightField);
//        } catch (IOException e) {
//            log.error(e.getMessage(), e);
//            initEsClient();
//            return service.searchListData(index, type, query, size, fields, sortField, highlightField);
//        }
//    }
//
//    /**
//     * 使用分词查询
//     *
//     * @param index          索引名称
//     * @param type           类型名称,可传入多个type逗号分隔，7.8.0版本该参数已经废弃
//     * @param query          查询条件
//     * @param size           文档大小限制
//     * @param fields         需要显示的字段，逗号分隔（缺省为全部字段）
//     * @param sortField      排序字段
//     * @param sortOrder      排序方式
//     * @param highlightField 高亮字段
//     * @return
//     */
//    public static List<Map<String, Object>> searchListData(String index, String type, QueryBuilder query, Integer size,
//                                                           String fields, String sortField, SortOrder sortOrder, String highlightField) throws IOException {
//        try {
//            return service.searchListData(index, type, query, size, fields, sortField, sortOrder, highlightField);
//        } catch (IOException e) {
//            log.error(e.getMessage(), e);
//            return service.searchListData(index, type, query, size, fields, sortField, sortOrder, highlightField);
//        }
//    }


}
